home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Enigma Amiga Life 109
/
EnigmaAmiga109CD.iso
/
dalla rivista
/
amiga.free
/
diropus4.12b_gpl
/
config
/
main7.c
< prev
next >
Wrap
C/C++ Source or Header
|
2000-01-27
|
17KB
|
586 lines
/*
Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.
The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.
*/
#include "config.h"
struct Gadget busygadget={
NULL,
0,0,0,0,
GFLG_GADGHNONE,0,GTYP_BOOLGADGET,
NULL,NULL,NULL,0,NULL,0,NULL};
static int oldidcmp,busyflag;
void busy()
{
if (!busyflag) {
busygadget.TopEdge=Window->BorderTop;
busygadget.LeftEdge=Window->BorderLeft;
busygadget.Width=Window->Width-Window->BorderLeft-Window->BorderRight;
busygadget.Height=Window->Height-Window->BorderTop-Window->BorderBottom;
AddGList(Window,&busygadget,0,1,NULL);
oldidcmp=Window->IDCMPFlags;
ModifyIDCMP(Window,IDCMP_CLOSEWINDOW);
Window->Flags|=WFLG_RMBTRAP;
SetBusyPointer(Window);
busyflag=1;
}
}
void unbusy()
{
if (busyflag) {
RemoveGList(Window,&busygadget,1);
ModifyIDCMP(Window,oldidcmp);
Window->Flags&=~WFLG_RMBTRAP;
ClearPointer(Window);
busyflag=0;
}
}
void dosave(new)
int new;
{
char buf[80];
busy();
if (new) {
trysave:
makefilebuffer(configname);
filereq.flags=DFRF_SAVE;
filereq.title=cfg_string[STR_ENTER_CONFIGURATION_FILENAME];
filereq.window=Window;
if (!(FileRequest(&filereq))) {
unbusy();
return;
}
strcpy(configname,dirbuf);
TackOn(configname,filebuf,256);
if (!(strstri(configname,".CFG"))) StrConcat(configname,".CFG",256);
}
fixcstuff(&cstuff);
if (!SaveConfig(configname,&cstuff)) {
lsprintf(buf,cfg_string[STR_SAVE_FAILED],IoErr());
if (request(buf)) goto trysave;
}
else lchanged=changed=0;
unbusy();
}
doload(type,def)
int type,def;
{
char *path,buf[80],*menulist[6],menuarray[6],**ftypelist,*typearray;
struct DOpusRemember *fkey;
struct ConfigStuff *newcstuff;
struct dopusgadgetbanks *bank,*bank2,*nbank;
struct dopusfiletype *ftype,*ntype;
struct dopushotkey *fhotkey,*nhotkey,*curhotkey;
int a,b,c,freecon=0,ret,m1,m2;
busy();
fkey=NULL;
if (def) {
tryload:
if (type==CFG_MAINMENU) path=configname;
else path=loadnamebuf;
makefilebuffer(path);
filereq.flags=0;
filereq.title=cfg_string[STR_SELECT_CONFIGURATION_TO_LOAD];
filereq.window=Window;
if (!(FileRequest(&filereq))) {
unbusy();
return(0);
}
strcpy(loadnamebuf,dirbuf);
TackOn(loadnamebuf,filebuf,256);
if (!(strstri(loadnamebuf,".CFG"))) StrConcat(loadnamebuf,".CFG",256);
}
if (!(newcstuff=AllocMem(sizeof(struct ConfigStuff),MEMF_CLEAR)) ||
!(newcstuff->config=AllocMem(sizeof(struct Config),MEMF_CLEAR))) {
if (newcstuff) FreeMem(newcstuff,sizeof(struct ConfigStuff));
unbusy();
return(0);
}
fixcstuff(&cstuff);
if (def) {
lchanged=changed=0;
SetBusyPointer(Window);
if ((a=ReadConfig(loadnamebuf,newcstuff))!=1) {
ClearPointer(Window);
if (a==ERROR_NOT_CONFIG) strcpy(buf,cfg_string[STR_FILE_NOT_VALID_CONFIGURATION]);
else lsprintf(buf,cfg_string[STR_OPEN_FAILED],a);
if (request(buf)) goto tryload;
}
else {
lchanged=1;
ClearPointer(Window);
CheckConfig(newcstuff);
}
}
else {
DefaultConfig(newcstuff);
lchanged=1;
}
if (lchanged) {
ret=1;
switch (type) {
case CFG_MAINMENU:
FreeConfig(&cstuff);
CopyMem((char *)newcstuff,(char *)&cstuff,sizeof(struct ConfigStuff));
cstuff.config=config;
CopyMem((char *)newcstuff->config,(char *)config,sizeof(struct Config));
strcpy(configname,loadnamebuf);
freecon=1;
break;
case CFG_OPERATION:
CopyMem((char *)&newcstuff->config->copyflags,(char *)&config->copyflags,
(offsetof(struct Config,dynamicflags)-offsetof(struct Config,copyflags))+1);
config->dateformat=newcstuff->config->dateformat;
config->formatflags=newcstuff->config->formatflags;
for (a=0;a<2;a++) {
config->sortmethod[a]=newcstuff->config->sortmethod[a];
config->separatemethod[a]=newcstuff->config->separatemethod[a];
CopyMem((char *)newcstuff->config->displaypos[a],(char *)config->displaypos[a],16);
CopyMem((char *)newcstuff->config->displaylength[a],(char *)config->displaylength[a],16);
}
freecon=3;
break;
case CFG_GADGET:
if (bank=firstbank) {
while (bank->next) bank=bank->next;
}
bank2=newcstuff->firstbank;
while (bank2) {
if (nbank=(struct dopusgadgetbanks *)
getcopy((char *)bank2,sizeof(struct dopusgadgetbanks),NULL)) {
nbank->next=NULL;
if (bank) bank->next=nbank;
else firstbank=nbank;
bank=nbank;
copygadgets(bank2,bank,NULL);
}
bank2=bank2->next;
}
cstuff.firstbank=firstbank;
freecon=3;
break;
case CFG_MENU:
freecon=3;
for (a=0;a<6;a++) {
menulist[a]=NULL;
menuarray[a]=0;
}
for (a=0,b=0;a<5;a++) {
if (newcstuff->config->menutit[a][0])
menulist[b++]=newcstuff->config->menutit[a];
}
if (!menulist[0] ||
!(dolistwindow(cfg_string[STR_SELECT_MENUS_TO_IMPORT],
332,40,menulist,DLVF_MULTI|DLVF_HIREC,menuarray,NULL))) {
ret=0;
break;
}
for (a=0,b=0;a<5;a++) {
m1=a*20; m2=(a+1)*20;
for (c=m1;c<m2;c++)
if (config->menu[c].name && config->menu[c].name[0]) break;
if (c==m2) {
while (!menuarray[b]) if ((++b)>4) break;
if (b>4) break;
for (c=m1;c<m2;c++) freenewfunction(&config->menu[c]);
CopyMem((char *)&newcstuff->config->menu[b*20],
(char *)&config->menu[m1],sizeof(struct dopusfunction)*20);
for (c=m1;c<m2;c++) {
config->menu[c].name=getcopy(config->menu[c].name,-1,NULL);
config->menu[c].function=getcopy(config->menu[c].function,-1,NULL);
}
strcpy(config->menutit[a],newcstuff->config->menutit[b]);
++b;
}
}
break;
case CFG_DRIVE:
for (a=0;a<DRIVECOUNT;a++) freestring(config->drive[a].function);
CopyMem((char *)newcstuff->config->drive,(char *)config->drive,sizeof(struct dopusfunction)*DRIVECOUNT);
for (a=0;a<DRIVECOUNT;a++)
config->drive[a].function=getcopy(newcstuff->config->drive[a].function,-1,NULL);
freecon=3;
break;
case CFG_FILETYPE:
freecon=3;
b=0;
ftype=newcstuff->firsttype;
while (ftype) {
b++;
ftype=ftype->next;
}
if (!(ftypelist=LAllocRemember(&fkey,(b+1)*4,MEMF_CLEAR)) ||
!(typearray=LAllocRemember(&fkey,b+1,MEMF_CLEAR))) break;
ftype=newcstuff->firsttype;
for (a=0;a<b;a++) {
ftypelist[a]=ftype->type;
ftype=ftype->next;
}
if (!ftypelist[0] ||
!(dolistwindow(cfg_string[STR_SELECT_FILETYPES_TO_IMPORT],
332,72,ftypelist,DLVF_MULTI|DLVF_HIREC,typearray,NULL))) {
ret=0;
break;
}
ftype=newcstuff->firsttype; b=0;
while (ftype) {
if (typearray[b]) {
if (ntype=(struct dopusfiletype *)
getcopy((char *)ftype,sizeof(struct dopusfiletype),&typekey)) {
ntype->next=NULL;
ntype->recognition=getcopy(ftype->recognition,-1,&typekey);
ntype->iconpath=getcopy(ftype->iconpath,-1,&typekey);
for (a=0;a<FILETYPE_FUNCNUM;a++)
ntype->function[a]=getcopy(ftype->function[a],-1,&typekey);
addfiletype(ntype);
}
}
ftype=ftype->next; ++b;
}
cstuff.firsttype=firsttype;
break;
case CFG_HOTKEYS:
freecon=3;
b=0;
curhotkey=firsthotkey;
while (curhotkey && curhotkey->next) curhotkey=curhotkey->next;
fhotkey=newcstuff->firsthotkey;
while (fhotkey) {
b++;
fhotkey=fhotkey->next;
}
if (!(ftypelist=LAllocRemember(&fkey,(b+1)*4,MEMF_CLEAR)) ||
!(typearray=LAllocRemember(&fkey,b+1,MEMF_CLEAR))) break;
fhotkey=newcstuff->firsthotkey;
for (a=0;a<b;a++) {
ftypelist[a]=fhotkey->name;
fhotkey=fhotkey->next;
}
if (!ftypelist[0] ||
!(dolistwindow(cfg_string[STR_SELECT_HOTKEYS_TO_IMPORT],
332,72,ftypelist,DLVF_MULTI|DLVF_HIREC,typearray,NULL))) {
ret=0;
break;
}
fhotkey=newcstuff->firsthotkey; b=0;
while (fhotkey) {
if (typearray[b]) {
if (nhotkey=(struct dopushotkey *)
getcopy((char *)fhotkey,sizeof(struct dopushotkey),NULL)) {
nhotkey->next=NULL;
nhotkey->func.function=getcopy(fhotkey->func.function,-1,NULL);
if (curhotkey) curhotkey->next=nhotkey;
else firsthotkey=nhotkey;
curhotkey=nhotkey;
}
}
fhotkey=fhotkey->next; ++b;
}
cstuff.firsthotkey=firsthotkey;
break;
case CFG_SCREEN:
CopyMem((char *)&newcstuff->config->gadgettopcol,
(char *)&config->gadgettopcol,
offsetof(struct Config,pad4)-offsetof(struct Config,gadgettopcol));
CopyMem(newcstuff->config->fontsizes,config->fontsizes,NUMFONTS);
CopyMem(newcstuff->config->fontbufs,config->fontbufs,NUMFONTS*40);
config->sliderbgcol=newcstuff->config->sliderbgcol;
config->stringfgcol=newcstuff->config->stringfgcol;
config->stringbgcol=newcstuff->config->stringbgcol;
config->sliderwidth=newcstuff->config->sliderwidth;
config->sliderheight=newcstuff->config->sliderheight;
config->stringheight=newcstuff->config->stringheight;
config->stringselfgcol=newcstuff->config->stringselfgcol;
config->stringselbgcol=newcstuff->config->stringselbgcol;
config->generalscreenflags=newcstuff->config->generalscreenflags;
CopyMem((char *)newcstuff->config->scrollborders,
(char *)config->scrollborders,sizeof(struct Rectangle)*2);
CopyMem((char *)newcstuff->config->new_palette,
(char *)config->new_palette,sizeof(ULONG)*48);
strcpy(config->pubscreen_name,newcstuff->config->pubscreen_name);
config->slider_pos=newcstuff->config->slider_pos;
freecon=3;
break;
case CFG_SYSTEM:
CopyMem((char *)newcstuff->config->outputcmd,(char *)config->outputcmd,
offsetof(struct Config,gadgetrows)-offsetof(struct Config,outputcmd));
CopyMem((char *)newcstuff->config->startupscript,(char *)config->startupscript,
offsetof(struct Config,pad8)-offsetof(struct Config,startupscript));
strcpy(config->uniconscript,newcstuff->config->uniconscript);
config->addiconflags=newcstuff->config->addiconflags;
strcpy(config->shellstartup,newcstuff->config->shellstartup);
strcpy(config->language,newcstuff->config->language);
config->loadexternal=newcstuff->config->loadexternal;
freecon=3;
break;
}
lchanged=changed=0;
}
else {
freecon=1;
ret=0;
}
if (freecon&2) FreeConfig(newcstuff);
if (freecon&1) FreeMem(newcstuff->config,sizeof(struct Config));
FreeMem(newcstuff,sizeof(struct ConfigStuff));
cstufffix(&cstuff);
LFreeRemember(&fkey);
unbusy();
return(ret);
}
void copyconfigonly(config1,config2)
struct Config *config1,*config2;
{
struct newdopusfunction *menubackup;
struct dopusfunction *drivebackup;
struct DOpusRemember *key;
key=NULL;
menubackup=(struct newdopusfunction *)
getcopy((char *)config2->menu,sizeof(struct dopusfunction)*MENUCOUNT,&key);
drivebackup=(struct dopusfunction *)
getcopy((char *)config2->drive,sizeof(struct dopusfunction)*DRIVECOUNT,&key);
CopyMem((char *)config1,(char *)config2,sizeof(struct Config));
if (menubackup) CopyMem((char *)menubackup,(char *)config2->menu,sizeof(struct newdopusfunction)*MENUCOUNT);
if (drivebackup) CopyMem((char *)drivebackup,(char *)config2->drive,sizeof(struct dopusfunction)*DRIVECOUNT);
LFreeRemember(&key);
}
dolistwindow(title,w,h,items,flags,selarray,item)
char *title;
int w,h;
char **items;
int flags;
char *selarray;
int *item;
{
struct Window *wind;
struct DOpusListView *view;
ULONG class;
USHORT code;
int a,gadgetid,all=1,count;
char **gadtxt;
listlist.w=w;
listlist.h=h;
if (selarray && flags&DLVF_MULTI) {
listokaygad[0].NextGadget=&listokaygad[2];
listokaygad[2].NextGadget=&listokaygad[1];
gadtxt=listviewgads2;
count=3;
}
else {
listokaygad[0].NextGadget=&listokaygad[1];
gadtxt=listviewgads;
count=2;
}
listokaygad[1].NextGadget=NULL;
setup_list_window(&requestwin,&listlist,listokaygad,count);
listlist.items=items;
listlist.selectarray=selarray;
listlist.flags=flags;
listlist.itemselected=-1;
setuplist(&listlist,-1,-1);
requestwin.Title=title;
if (!(wind=openwindow(&requestwin))) return(0);
listlist.window=wind;
if (!(AddListView(&listlist,1))) {
CloseWindow(wind);
return(0);
}
SetAPen(wind->RPort,screen_pens[1].pen);
AddGadgets(wind,
listokaygad,
gadtxt,
count,
screen_pens[config->gadgettopcol].pen,screen_pens[config->gadgetbotcol].pen,1);
busy();
FOREVER {
Wait(1<<wind->UserPort->mp_SigBit);
while (IMsg=(struct IntuiMessage *)GetMsg(wind->UserPort)) {
if ((view=ListViewIDCMP(&listlist,IMsg))==(struct DOpusListView *)-1) {
class=IMsg->Class; code=IMsg->Code;
if (class==IDCMP_GADGETUP || class==IDCMP_GADGETDOWN)
gadgetid=((struct Gadget *)IMsg->IAddress)->GadgetID;
ReplyMsg((struct Message *)IMsg);
if (class==IDCMP_VANILLAKEY) {
a=-1;
if (code=='\r' || code=='o' || code=='y') a=0;
else if (code=='' || code=='c' || code=='n') a=1;
if (a!=-1) {
SelectGadget(wind,&listokaygad[a]);
class=GADGETUP; gadgetid=1-a;
}
}
if (class==IDCMP_GADGETUP) {
if (gadgetid<2) {
unbusy();
RemoveListView(&listlist,1);
CloseWindow(wind);
return(gadgetid);
}
else if (gadgetid==2 && flags&DLVF_MULTI) {
for (a=0;a<listlist.count;a++) selarray[a]=all;
RefreshListView(&listlist,1);
all=1-all;
}
}
}
else if (view) {
if (flags&DLVF_MULTI)
selarray[view->itemselected]=1-selarray[view->itemselected];
else {
if (item) *item=view->itemselected;
if (!(flags&DLVF_LEAVE)) {
unbusy();
RemoveListView(&cmdlist,1);
CloseWindow(wind);
return(1);
}
}
}
}
}
}
void copytoclip(func,funclist,functype,flagsel)
struct dopusfunction *func;
char **funclist,*functype,*flagsel;
{
struct Clip *newclip,*pos;
busy();
if (newclip=LAllocRemember(&clipkey,sizeof(struct Clip),MEMF_CLEAR)) {
newclip->func.function=compilefunclist(funclist,functype,&clipkey);
newclip->func.which=getselflags(flagsel);
newclip->func.stack=atoi(edit_stackbuf);
newclip->func.pri=atoi(edit_prioritybuf);
newclip->func.delay=atoi(edit_delaybuf);
newclip->func.fpen=func->fpen;
newclip->func.bpen=func->bpen;
strcpy(newclip->name,edit_namebuf);
pos=firstclip;
while (pos && pos->next) pos=pos->next;
if (pos) pos->next=newclip;
else firstclip=newclip;
++clipcount;
}
unbusy();
}
pasteclip(func,funclist,functype,displist,flagsel)
struct dopusfunction *func;
char **funclist,*functype,**displist,*flagsel;
{
char **cliplist;
struct DOpusRemember *key=NULL;
struct Clip *clip;
int a,b,ret=0;
if (!clipcount) return(0);
if (!(cliplist=LAllocRemember(&key,(clipcount+1)*4,MEMF_CLEAR))) return(0);
busy();
clip=firstclip;
for (a=0;a<clipcount;a++) {
if (!clip) break;
if (!(cliplist[a]=LAllocRemember(&key,40,MEMF_CLEAR))) break;
strcpy(cliplist[a],clip->name);
clip=clip->next;
}
cliplist[a]=NULL;
if (dolistwindow(cfg_string[STR_SELECT_FUNCTION_TO_PASTE],
212,40,cliplist,DLVF_LEAVE|DLVF_HIREC,NULL,&a)) {
clip=firstclip;
for (b=0;b<a;b++) if (!(clip=clip->next)) break;
if (clip) {
erasefunction(func,funclist,displist,flagsel);
lsprintf(edit_stackbuf,"%ld",clip->func.stack);
lsprintf(edit_prioritybuf,"%ld",clip->func.pri);
lsprintf(edit_delaybuf,"%ld",clip->func.delay);
strcpy(edit_namebuf,clip->name);
func->key=0; func->qual=0;
func->fpen=clip->func.fpen; func->bpen=clip->func.bpen;
makefunclist(clip->func.function,funclist,functype);
for (a=0;a<MAXFUNCS;a++) makedispfunc(funclist[a],functype[a],displist[a]);
makeselflags(clip->func.which,flagsel);
ret=1;
}
}
LFreeRemember(&key);
unbusy();
return(ret);
}
void makefilebuffer(buf)
char *buf;
{
char *ptr;
strcpy(dirbuf,buf);
ptr=BaseName(dirbuf);
if (ptr>dirbuf) {
strcpy(filebuf,ptr);
*ptr=0;
}
else if (CheckExist(dirbuf,NULL)<1) {
dirbuf[0]=0;
strcpy(filebuf,buf);
}
}
char *strstri(string,substring)
char *string,*substring;
{
int a,len,sublen;
len=(strlen(string)-(sublen=strlen(substring)))+1;
if (len<1) return(NULL);
for (a=0;a<len;a++) {
if (LStrnCmpI(&string[a],substring,sublen)==0)
return(string+a);
}
return(NULL);
}